package cn.rkylin.oms.item.service;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import cn.rkylin.apollo.common.util.DateUtils;
import cn.rkylin.oms.common.utils.DateUtil;
import cn.rkylin.oms.item.adapter.ItemAdapter;
import cn.rkylin.oms.item.adapter.ItemAdapterFactory;
import cn.rkylin.oms.item.controller.ItemController;
import cn.rkylin.oms.item.request.DelistingItemRequest;
import cn.rkylin.oms.item.request.ListingItemRequest;
import cn.rkylin.oms.system.shop.dao.ShopDAOImpl;
import cn.rkylin.oms.system.shop.service.ShopServiceImpl;
import cn.rkylin.oms.system.shop.vo.ShopVO;
import com.alibaba.fastjson.JSONObject;
import org.apache.commons.lang.StringUtils;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;

import com.alibaba.fastjson.JSON;
import com.github.pagehelper.PageInfo;

import cn.rkylin.apollo.common.util.HttpUtils;
import cn.rkylin.core.IDataBaseFactory;
import cn.rkylin.core.service.ApolloService;
import cn.rkylin.core.utils.StringUtil;
import cn.rkylin.oms.common.consts.YesNoConst;
import cn.rkylin.oms.common.context.CurrentUser;
import cn.rkylin.oms.common.context.WebContextFactory;
import cn.rkylin.oms.common.dto.DBLog;
import cn.rkylin.oms.common.utils.CodeUtil;
import cn.rkylin.oms.common.utils.LogUtil;
import cn.rkylin.oms.goods.service.IGoodsService;
import cn.rkylin.oms.goods.vo.Goods;
import cn.rkylin.oms.goods.vo.GoodsInfoVO;
import cn.rkylin.oms.goods.vo.GoodsSku;
import cn.rkylin.oms.goods.vo.GoodsSkuVO;
import cn.rkylin.oms.goods.vo.GoodsVO;
import cn.rkylin.oms.goods.vo.PrjSkuVO;
import cn.rkylin.oms.item.dao.IEcSkuGroupDAO;
import cn.rkylin.oms.item.dao.IItemDAO;
import cn.rkylin.oms.item.domain.SkuGroup;
import cn.rkylin.oms.item.vo.EcSkuGroupVO;
import cn.rkylin.oms.item.vo.GroupSku;
import cn.rkylin.oms.item.vo.GroupSkuInfo;
import cn.rkylin.oms.item.vo.ItemVO;
import cn.rkylin.oms.item.vo.SkuVO;
import cn.rkylin.oms.order.service.IOrderService;
import cn.rkylin.oms.order.vo.OrderSkuVO;
import cn.rkylin.oms.push.request.PushItemListing;
import cn.rkylin.oms.system.stockpush.domain.StockFmla;
import cn.rkylin.oms.system.stockpush.service.IStockPushService;

/**
 * 平台商品管理服务实现
 *
 * @author wangxing
 * @version 1.0
 * @created 16-2月-2017 9:00:00
 */

@Service("itemService")
public class ItemServiceImpl extends ApolloService implements IItemService {
    private static final Log logger = LogFactory.getLog(ItemServiceImpl.class);
	
    @Autowired
    private LogUtil logUtil;

    @Value("${oms.address}")
    private String omsAddres;

    @Value("${job.address}")
    private String jobAddress;

    @Autowired
    private IDataBaseFactory dao;

    @Autowired
    public IOrderService orderService;

    /**
     * 系统商品数据访问
     */
    @Autowired
    private IEcSkuGroupDAO ecSkuGroupDAO;

    @Autowired
    private IEcSkuGroupService ecSkuGroupService;

    @Autowired
    private IStockPushService stockPushService;

    /**
     * 平台商品数据访问
     */
    @Autowired
    private IItemDAO itemDAO;

    /**
     * 系统商品服务层
     */
    @Autowired
    private IGoodsService goodsService;

    public IItemDAO getItemDAO() {
        return itemDAO;
    }

    public void setItemDAO(IItemDAO itemDAO) {
        this.itemDAO = itemDAO;
    }


    @Autowired
    ShopDAOImpl shopDAO;

    /**
     * 构造函数
     */
    public ItemServiceImpl() {

    }

    /**
     * 查询平台商品
     *
     * @param page
     * @param rows
     * @param itemVO
     * @return
     * @throws Exception
     */
    public PageInfo<ItemVO> findByWhere(int page, int rows, ItemVO itemVO) throws Exception {
        // PageInfo<ItemVO> itemVOList = findPage(page, rows, "pageSelectItem",
        // itemVO, skuVO);
        PageInfo<ItemVO> itemVOList = findPage(page, rows, "pageSelectItem", itemVO);
        return itemVOList;
    }

    /**
     * 查询平台规格
     *
     * @param page
     * @param rows
     * @param skuVO
     * @return
     * @throws Exception
     */
    public PageInfo<SkuVO> findByWhere(int page, int rows, SkuVO skuVO) throws Exception {
        PageInfo<SkuVO> skuVOList = findPage(page, rows, "pageSelectSku", skuVO);
        return skuVOList;
    }

    @Override
    public List<SkuVO> findByWhere(SkuVO skuVO) throws Exception {
        List<SkuVO> skuVOList = findPage("pageSelectSku", skuVO);
        return skuVOList;
    }

    /**
     * 根据itemCode找EcItem
     *
     * @param id
     * @return
     * @throws Exception
     */
    @Override
    @Cacheable(value = "ItemVO", key = "T(String).valueOf('ecItem:').concat(#itemVO.shopId).concat(':').concat(#itemVO.ecItemCode)")
    public List<ItemVO> findByItemCode(ItemVO itemVO) throws Exception {
        List<ItemVO> list = findPage("selectByItemCodeItem", itemVO);
        return list;
    }

    /**
     * 根据ID找EcItem
     *
     * @param id
     * @return
     * @throws Exception
     */
    @Override
    public ItemVO getEcItemById(String id) throws Exception {
        ItemVO vo = itemDAO.findById(id);
        return vo;
    }

    /**
     * 画面VO检查
     *
     * @param goodsInfo
     * @return
     */
    private Map<String, String> checkGroupSkuInfo(GroupSkuInfo groupSkuInfo) {
        Map<String, String> result = new HashMap<String, String>();

        // 空
        if (groupSkuInfo == null) {
            result.put("isOk", "n");
            result.put("errorMessage", "画面VO为空");
            return result;
        }

        result.put("isOk", "y");
        result.put("errorMessage", "");

        return result;
    }

    private String addGroupSku(GroupSku groupSku, String ecItemId, String ecSkuId) throws Exception {
        SkuGroup ecSkuGroup = new SkuGroup();
        ecSkuGroup.setEcSkuGroupId(java.util.UUID.randomUUID().toString().replaceAll("-", ""));
        ecSkuGroup.setEcSkuId(ecSkuId);
        ecSkuGroup.setEcItemId(ecItemId);
        ecSkuGroup.setSkuId(groupSku.getSkuId());
        ecSkuGroup.setSkuCode(groupSku.getSkuCode());
        ecSkuGroup.setSkuName(groupSku.getSkuName());
        ecSkuGroup.setGoodsId(groupSku.getGoodsId());
        ecSkuGroup.setGoodsCode(groupSku.getGoodsName());
        ecSkuGroup.setGoodsName(groupSku.getGoodsName());
        ecSkuGroup.setCreateTime(new Date());
        ecSkuGroup.setUpdateTime(new Date());
        ecSkuGroup.setNum(Integer.valueOf(groupSku.getNum()).intValue());
        if (StringUtils.isNotBlank(groupSku.getPriceRatio())) {
            ecSkuGroup.setPriceRatio(new BigDecimal(groupSku.getPriceRatio()));
        }
        if (StringUtils.isNotBlank(groupSku.getUpRate())) {
            ecSkuGroup.setUpRate(new BigDecimal(groupSku.getUpRate()));
        }
        ecSkuGroup.setRemark(groupSku.getRemark());
        ecSkuGroup.setDeleted("n");
        ecSkuGroupDAO.insert(ecSkuGroup);
        return ecSkuGroup.getSkuId();
    }

    private String updateGroupSku(GroupSku groupSku) throws Exception {
        SkuGroup ecSkuGroup = new SkuGroup();
        ecSkuGroup.setEcSkuGroupId(groupSku.getEcSkuGroupId());
        ecSkuGroup.setUpdateTime(new Date());
        ecSkuGroup.setNum(Integer.valueOf(groupSku.getNum()).intValue());
        if (StringUtils.isNotBlank(groupSku.getPriceRatio())) {
            ecSkuGroup.setPriceRatio(new BigDecimal(groupSku.getPriceRatio()));
        }
        if (StringUtils.isNotBlank(groupSku.getUpRate())) {
            ecSkuGroup.setUpRate(new BigDecimal(groupSku.getUpRate()));
        }
        ecSkuGroup.setRemark(groupSku.getRemark());
        ecSkuGroupDAO.update(ecSkuGroup);
        return ecSkuGroup.getSkuId();
    }

    private String delGroupSku(GroupSku groupSku) throws Exception {
        SkuGroup ecSkuGroup = new SkuGroup();
        ecSkuGroup.setEcSkuGroupId(groupSku.getEcSkuGroupId());
        ecSkuGroup.setUpdateTime(new Date());
        ecSkuGroup.setDeleted("y");
        ecSkuGroupDAO.update(ecSkuGroup);
        return ecSkuGroup.getSkuId();
    }

    /**
     * 逻辑删除组合商品
     *
     * @param groupSku
     * @return
     * @throws Exception
     */
    private int delEcSkuGroupByEcSkuId(GroupSku groupSku) throws Exception {
        SkuGroup ecSkuGroup = new SkuGroup();
        ecSkuGroup.setEcSkuId(groupSku.getEcSkuId());
        ecSkuGroup.setUpdateTime(new Date());
        ecSkuGroup.setDeleted("y");
        int iRes = ecSkuGroupDAO.updateEcSkuGroupByEcSkuId(ecSkuGroup);
        return iRes;
    }

    private void updateEcSkuIsGroup(String id, String flg) throws Exception {
        SkuVO skuVO = new SkuVO();
        skuVO.setEcSkuId(id);
        skuVO.setUpdateTime(new Date());
        skuVO.setIsGroup(flg);
        itemDAO.updateEcSkuByGoodsSkuId(skuVO);
    }

    @Override
    public Map<String, Object> modifyGroupSkuData(GroupSkuInfo groupSkuInfo) throws Exception {
        Map<String, Object> result = new HashMap<String, Object>();

        // check
        Map<String, String> checkMap = checkGroupSkuInfo(groupSkuInfo);
        if ("n".equals(checkMap.get("isOk"))) {
            result.put("isOk", "n");
            result.put("count", "0");
            result.put("errorMessage", checkMap.get("errorMessage"));
            return result;
        }

        List<GroupSku> list = groupSkuInfo.getArrGroupSku();

        if (list != null) {
            //逻辑删除 当前平台规格所有的 组合商品
            GroupSku groupSkuTemp = new GroupSku();
            groupSkuTemp.setEcSkuId(groupSkuInfo.getEcSkuId());
            int iRes = delEcSkuGroupByEcSkuId(groupSkuTemp);


            for (int i = 0; i < list.size(); i++) {
                GroupSku groupSku = list.get(i);
                if ("insert".equals(groupSku.getAction())) {
                    addGroupSku(groupSku, groupSkuInfo.getEcItemId(), groupSkuInfo.getEcSkuId());
                }

//                    else if ("update".equals(groupSku.getAction())) {
//                        updateGroupSku(groupSku);
//                    } else if ("delete".equals(groupSku.getAction())) {
//                        delGroupSku(groupSku);
//                    }
            }


        }

        SkuVO param = new SkuVO();
        param.setEcItemId(groupSkuInfo.getEcItemId());
        List<SkuVO> skuVOList = findByWhere(param);
        if (skuVOList != null && skuVOList.size() > 0) {
            List<EcSkuGroupVO> eclist = ecSkuGroupService.getEcSkuGroupByEcSkuId(groupSkuInfo.getEcSkuId());
            if (eclist != null && eclist.size() > 0) {
                updateEcSkuIsGroup(groupSkuInfo.getEcSkuId(), YesNoConst.YES);
            } else {
                updateEcSkuIsGroup(groupSkuInfo.getEcSkuId(), YesNoConst.NO);
            }

            // 更新关联状态
            Map<String, Object> paramsA = new HashMap<String, Object>();
            paramsA.put("ecItemId", groupSkuInfo.getEcItemId());
            int skuAmount = itemDAO.selectAmountByEcItemId(paramsA);
            paramsA.put("groupFlg", "Y");
            int groupAmount = itemDAO.selectAmountByEcItemId(paramsA);
            Map<String, Object> paramsB = new HashMap<String, Object>();
            paramsB.put("ecItemId", groupSkuInfo.getEcItemId());
            paramsB.put("matchFlg", "Y");
            int matchAmount = itemDAO.selectAmountByEcItemId(paramsB);
            Map<String, Object> paramsC = new HashMap<String, Object>();
            paramsC.put("ecItemId", groupSkuInfo.getEcItemId());
            paramsC.put("unGroupAndMatchFlg", "Y");
            int unGroupAndMatchAmount = itemDAO.selectAmountByEcItemId(paramsC);
            String relateStatus = null;
            if (matchAmount == 0 && groupAmount == 0) {
                relateStatus = "none";
            } else if (matchAmount == skuAmount || (skuAmount - groupAmount) == unGroupAndMatchAmount) {
                relateStatus = "all";
            } else {
                relateStatus = "part";
            }
            ItemVO itemVo = new ItemVO();
            itemVo.setEcItemId(groupSkuInfo.getEcItemId());
            itemVo.setRelateStatus(relateStatus);
            itemDAO.updateRelateStatusByEcItemId(itemVo);
        }

        result.put("isOk", "y");
        result.put("count", "1");
        result.put("errorMessage", "");
        return result;
    }

    /**
     * 查询项目sku list
     *
     * @param param 查询参数
     * @param prjid 项目Id
     */
    public List<PrjSkuVO> getProjectSkuList(Map<String, Object> param) throws Exception {
        return dao.findList("selectPrjList", param);
    }

    /**
     * 查询项目sku list
     *
     * @param param 查询参数
     * @param prjid 项目Id
     */
    public List<PrjSkuVO> getProjectSkuList4SalesPromotion(Map<String, Object> param) throws Exception {
        return dao.findList("selectPrjSkuListForSalesPromotion", param);
    }

    /**
     * 自动关联系统商品
     *
     * @param ecitemid 平台商品Id
     * @param prjid    项目Id
     * @return 错误消息
     * @throws Exception 异常
     */
    public String autoRelationSysGoods(String[] ecitemid, String prjid) throws Exception {

        String errMsg = "以下平台商品编码存在关联失败的规格商品，请设置后重新关联。\\n";

        for (int i = 0; i < ecitemid.length; i++) {
            // 取得平台商品sku数据
            List<SkuVO> skuVoList = itemDAO.selectSkuByEcItemId(ecitemid[i]);

            for (int j = 0; j < skuVoList.size(); j++) {
                SkuVO skuVo = skuVoList.get(j);
                // 已关联系统商品
                if (!StringUtil.isEmpty(skuVo.getSkuId())) {
                    continue;
                }

                // 取得系统商品sku数据
                Map<String, String> reqMap = new HashMap<String, String>();
                reqMap.put("skuCode", skuVo.getOuterCode());
                reqMap.put("prjId", prjid);
                List<PrjSkuVO> prjSkuVoList = dao.findList("selectGoodsSkuCodeByPrjId", reqMap);
                PrjSkuVO prjSkuVo = null;
                if (prjSkuVoList != null && prjSkuVoList.size() > 0) {
                    prjSkuVo = prjSkuVoList.get(0);
                }

                // 商品编码***没有找到与之匹配的系统商品，请先将其添加系统商品再关联。
                if (prjSkuVo == null) {
                    errMsg = errMsg + skuVo.getEcItemCode() + "\\n";
                    break;
                }

                // 关联系统商品
                this.saveRelationSysGoods(skuVo, prjSkuVo);
            }
        }

        if ("以下平台商品编码存在关联失败的规格商品，请设置后重新关联。\\n".equals(errMsg)) {
            errMsg = "";
        }

        return errMsg;
    }

    /**
     * 手动关联系统商品
     *
     * @param ecSkuId  平台规格Id
     * @param prjSkuId 项目sku Id
     * @throws Exception 异常
     */
    public void manualRelationSysGoods(String ecSkuId, String prjSkuId) throws Exception {
        List<SkuVO> skuVoList = dao.findList("selectSkuByPrimaryKey", ecSkuId);
        SkuVO skuVo = null;
        if (skuVoList != null && skuVoList.size() > 0) {
            skuVo = skuVoList.get(0);
        }

        List<PrjSkuVO> prjSkuVoList = dao.findList("selectByPrimaryKeyPrjSku", prjSkuId);
        PrjSkuVO prjSkuVo = null;
        if (prjSkuVoList != null && prjSkuVoList.size() > 0) {
            prjSkuVo = prjSkuVoList.get(0);
        }

        // 关联系统商品
        this.saveRelationSysGoods(skuVo, prjSkuVo);
    }

    /**
     * 关联系统商品以后，更新订单项目对应的系统sku
     */
    public void doUpdateOrder(String ecSkuId, String prjSkuId) throws Exception {
        List<SkuVO> skuVoList = dao.findList("selectSkuByPrimaryKey", ecSkuId);
        // SkuVO skuVo = null;
        if (skuVoList != null && skuVoList.size() > 0) {
            SkuVO skuVo = skuVoList.get(0);

            OrderSkuVO orderSkuVO = new OrderSkuVO();
            orderSkuVO.setEcSkuId(ecSkuId);
            orderSkuVO.setSkuId(skuVo.getSkuId());
            orderSkuVO.setSkuCode(skuVo.getSkuCode());
            orderSkuVO.setSkuName(skuVo.getSkuName());
            orderSkuVO.setGoodsId(skuVo.getGoodsId());
            orderSkuVO.setGoodsCode(skuVo.getGoodsCode());
            orderSkuVO.setGoodsName(skuVo.getGoodsName());
            orderSkuVO.setUpdateTime(new Date());
            orderSkuVO.setOrderStatusForWher("a");
            // orderService.updateOrderSku(orderSkuVO);
            orderService.updateOrderSkuForEcSku(orderSkuVO);
        }

        // List<PrjSkuVO> prjSkuVoList =
        // dao.findList("selectByPrimaryKeyPrjSku", prjSkuId);
        // PrjSkuVO prjSkuVo = null;
        // if (prjSkuVoList != null && prjSkuVoList.size() > 0) {
        // prjSkuVo = prjSkuVoList.get(0);
        //
        // OrderSkuVO orderSkuVO = new OrderSkuVO();
        // orderSkuVO.setEcSkuId(ecSkuId);
        // orderSkuVO.setSkuId(prjSkuVo.getSkuId());
        // orderSkuVO.setSkuCode(prjSkuVo.getSkuCode());
        // orderSkuVO.setSkuName(prjSkuVo.getSkuName());
        // orderSkuVO.setGoodsId(prjSkuVo.getGoodsId());
        // orderSkuVO.setGoodsCode(prjSkuVo.getGoodsCode());
        // orderSkuVO.setGoodsName(prjSkuVo.getGoodsName());
        // orderSkuVO.setUpdateTime(new Date());
        // orderSkuVO.setOrderStatusForWher("a");
        // orderService.updateOrderSku(orderSkuVO);
        // }
    }

    /**
     * 取消关联系统商品
     *
     * @param ecSkuId 平台规格Id
     * @throws Exception 异常
     */
    public Map<String, Object> cancelRelationSysGoods(String ecSkuId) throws Exception {
        Map<String, Object> returnValue = new HashMap<String, Object>();

        List<SkuVO> skuVoList = dao.findList("selectSkuByPrimaryKey", ecSkuId);
        SkuVO skuVo = null;
        if (skuVoList != null && skuVoList.size() > 0) {
            skuVo = skuVoList.get(0);
            // 删除组合商品
            GroupSkuInfo groupSkuInfo = new GroupSkuInfo();
            groupSkuInfo.setEcItemId(skuVo.getEcItemId());
            groupSkuInfo.setEcSkuId(ecSkuId);
            List<GroupSku> arrGroupSku = new ArrayList<GroupSku>();

            List<EcSkuGroupVO> list = ecSkuGroupService.getEcSkuGroupByEcSkuId(ecSkuId);
            if (null != list && list.size() > 0) {
                for (EcSkuGroupVO ecSkuGroupVO : list) {
                    GroupSku groupSku = new GroupSku();
                    BeanUtils.copyProperties(ecSkuGroupVO, groupSku);
                    groupSku.setAction("delete");
                    arrGroupSku.add(groupSku);
                }
            }
            groupSkuInfo.setArrGroupSku(arrGroupSku);
            modifyGroupSkuData(groupSkuInfo);
            // 取消关联
            if (StringUtils.isBlank(skuVo.getSkuId()) && StringUtils.isBlank(skuVo.getSkuCode())
                    && StringUtils.isBlank(skuVo.getSkuName()) && StringUtils.isBlank(skuVo.getGoodsId())
                    && StringUtils.isBlank(skuVo.getGoodsCode()) && StringUtils.isBlank(skuVo.getGoodsName())) {
                returnValue.put("msg", "没有任何关联商品");
                returnValue.put("result", "false");
            } else {
                PrjSkuVO prjSkuVo = new PrjSkuVO();
                prjSkuVo.setSkuId("");
                prjSkuVo.setSkuCode("");
                prjSkuVo.setSkuName("");
                prjSkuVo.setGoodsId("");
                prjSkuVo.setGoodsCode("");
                prjSkuVo.setGoodsName("");
                // 取消关联系统商品
                this.saveRelationSysGoods(skuVo, prjSkuVo);
                returnValue.put("msg", "取消关联系统商品成功");
                returnValue.put("result", "success");
            }
        }
        return returnValue;
    }

    /**
     * batchancelRelCationSysGoods:批量取消关联系统商品
     *
     * @param ecitemid
     * @return
     */
    public Map<String, Object> batchancelRelCationSysGoods(String[] ecitemid) throws Exception {
        Map<String, Object> returnValue = new HashMap<String, Object>();
        Integer refalseCount = 0;
        for (int i = 0; i < ecitemid.length; i++) {
            // 取得平台商品sku数据
            List<SkuVO> skuVoList = itemDAO.selectSkuByEcItemId(ecitemid[i]);
            Integer falseCount = 0;
            for (int j = 0; j < skuVoList.size(); j++) {
                SkuVO skuVo = skuVoList.get(j);

                // 删除组合商品
                GroupSkuInfo groupSkuInfo = new GroupSkuInfo();
                groupSkuInfo.setEcItemId(skuVo.getEcItemId());
                groupSkuInfo.setEcSkuId(skuVo.getEcSkuId());
                List<GroupSku> arrGroupSku = new ArrayList<GroupSku>();

                List<EcSkuGroupVO> list = ecSkuGroupService.getEcSkuGroupByEcSkuId(skuVo.getEcSkuId());
                if (null != list && list.size() > 0) {
                    for (EcSkuGroupVO ecSkuGroupVO : list) {
                        GroupSku groupSku = new GroupSku();
                        BeanUtils.copyProperties(ecSkuGroupVO, groupSku);
                        groupSku.setAction("delete");
                        arrGroupSku.add(groupSku);
                    }
                }
                groupSkuInfo.setArrGroupSku(arrGroupSku);
                modifyGroupSkuData(groupSkuInfo);

                if (StringUtils.isBlank(skuVo.getSkuId()) && StringUtils.isBlank(skuVo.getSkuCode())
                        && StringUtils.isBlank(skuVo.getSkuName()) && StringUtils.isBlank(skuVo.getGoodsId())
                        && StringUtils.isBlank(skuVo.getGoodsCode()) && StringUtils.isBlank(skuVo.getGoodsName())) {
                    falseCount++;
                } else {
                    PrjSkuVO prjSkuVo = new PrjSkuVO();
                    prjSkuVo.setSkuId("");
                    prjSkuVo.setSkuCode("");
                    prjSkuVo.setSkuName("");
                    prjSkuVo.setGoodsId("");
                    prjSkuVo.setGoodsCode("");
                    prjSkuVo.setGoodsName("");
                    // 取消关联系统商品
                    this.saveRelationSysGoods(skuVo, prjSkuVo);
                }
            }
            if (skuVoList.size() == falseCount) {
                refalseCount++;
            }
        }
        if (ecitemid.length == refalseCount) {
            returnValue.put("msg", "没有任何关联商品");
            returnValue.put("result", "failed");
        } else {
            returnValue.put("msg", "取消关联系统商品成功");
            returnValue.put("result", "success");
        }
        return returnValue;
    }

    /**
     * 关联系统商品
     *
     * @param skuVo    平台sku VO
     * @param prjSkuVo 项目sku VO
     * @throws Exception 异常
     */
    private void saveRelationSysGoods(SkuVO skuVo, PrjSkuVO prjSkuVo) throws Exception {

        // 关联系统商品
        SkuVO relationSkuVo = new SkuVO();
        relationSkuVo.setEcSkuId(skuVo.getEcSkuId());
        relationSkuVo.setSkuId(prjSkuVo.getSkuId());
        relationSkuVo.setSkuCode(prjSkuVo.getSkuCode());
        relationSkuVo.setSkuName(prjSkuVo.getSkuName());
        relationSkuVo.setGoodsId(prjSkuVo.getGoodsId());
        relationSkuVo.setGoodsCode(prjSkuVo.getGoodsCode());
        relationSkuVo.setGoodsName(prjSkuVo.getGoodsName());
        itemDAO.updateSkubyEcSkuId(relationSkuVo);

        // 更新关联状态
        Map<String, Object> paramsA = new HashMap<String, Object>();
        paramsA.put("ecItemId", skuVo.getEcItemId());
        int skuAmount = itemDAO.selectAmountByEcItemId(paramsA);
        paramsA.put("groupFlg", "Y");
        int groupAmount = itemDAO.selectAmountByEcItemId(paramsA);
        Map<String, Object> paramsB = new HashMap<String, Object>();
        paramsB.put("ecItemId", skuVo.getEcItemId());
        paramsB.put("matchFlg", "Y");
        int matchAmount = itemDAO.selectAmountByEcItemId(paramsB);
        Map<String, Object> paramsC = new HashMap<String, Object>();
        paramsC.put("ecItemId", skuVo.getEcItemId());
        paramsC.put("unGroupAndMatchFlg", "Y");
        int unGroupAndMatchAmount = itemDAO.selectAmountByEcItemId(paramsC);
        String relateStatus = null;
        if (matchAmount == 0 && groupAmount == 0) {
            relateStatus = "none";
        } else if (matchAmount == skuAmount || (skuAmount - groupAmount) == unGroupAndMatchAmount) {
            relateStatus = "all";
        } else {
            relateStatus = "part";
        }
        ItemVO itemVo = new ItemVO();
        itemVo.setEcItemId(skuVo.getEcItemId());
        itemVo.setRelateStatus(relateStatus);
        itemDAO.updateRelateStatusByEcItemId(itemVo);

        logUtil.info(new DBLog(skuVo.getEcSkuCode(), skuVo.getEcSkuName(), "平台商品", "关联系统商品成功"));
    }

    /**
     * 批量设置
     *
     * @param ecItemId  平台商品Id
     * @param listingYn (y:上架,n:下架)
     * @throws Exception 异常
     */
    public void batchSetting(String[] ecItemId, String listingYn) throws Exception {
        if (ecItemId != null) {
            for (int i = 0; i < ecItemId.length; i++) {
                ItemVO itemVo = new ItemVO();
                itemVo.setEcItemId(ecItemId[i]);
                itemVo.setAutoList(listingYn);
                itemDAO.updateItem(itemVo);
            }
        }
    }

    /**
     * 商品上下架
     *
     * @param ecitemid   平台商品Id
     * @param listingFlg (true:上架,false:下架)
     * @return 错误消息
     * @throws Exception 异常
     */
    @SuppressWarnings("unchecked")
    public String listingItem(String[] ecitemid, boolean listingFlg) throws Exception {
        String errMsg = "";
        if (listingFlg) {
            errMsg = "以下商品上架失败！\\n";
        } else {
            errMsg = "以下商品下架失败！\\n";
        }
        String errItemNotFound = "商品未找到,平台商品编码为：\\n";
        String errDeleted = "商品已删除,平台商品编码为：\\n";
        String errShopNonentity = "店铺不存在,平台商品编码为：\\n";
        String errQty = "上架数为0,平台商品编码为：\\n";
        String errSystem = "";
        // String errStock = "商品库存为0,商品编码为:(";

        for (int i = 0; i < ecitemid.length; i++) {
            // 前台竟然会传空过来？乖乖
            if (StringUtils.isBlank(ecitemid[i])) {
                continue;
            }
            ItemVO httpItemVo = itemDAO.findById(ecitemid[i]);
            String resJson = "";
            // todo You like you to delete
            ShopVO shopVO = shopDAO.findById(httpItemVo.getShopId());
            ItemAdapter itemAdapter = ItemAdapterFactory.getAdapter(shopVO.getShopType());
            if (itemAdapter != null) {
                if (listingFlg) {
                    // 上架
                    ListingItemRequest listingItemRequest = new ListingItemRequest();
                    listingItemRequest.setEcItemCode(httpItemVo.getEcItemCode());
                    // TODO: 库存数量取出方式未定
                    listingItemRequest.setStockCount("0");
                    resJson = itemAdapter.listingItem(shopVO.getShopId(), listingItemRequest);
                } else {
                    // 下架
                    DelistingItemRequest delistingItemRequest = new DelistingItemRequest();
                    delistingItemRequest.setEcItemCode(httpItemVo.getEcItemCode());
                    resJson = itemAdapter.delistingItem(shopVO.getShopId(), delistingItemRequest);
                }
            } else {
                PushItemListing request = new PushItemListing();
                request.setShopId(httpItemVo.getShopId());
                request.setEcItemCode(httpItemVo.getEcItemCode());
                // TODO: 库存数量取出方式未定
                request.setStockCount("0");
                String url = "";
                if (listingFlg) { // 上架
                    url = omsAddres + "pushItem/pushItemListing.action";
                } else { // 下架
                    url = omsAddres + "pushItem/pushItemDeListing.action";
                }
                resJson = HttpUtils.sendByPost(url, JSON.toJSONString(request));
            }
            // 转换响应数据
            Map<String, String> resultMap = JSON.parseObject(resJson, Map.class);
            if (!resultMap.containsKey("success") || !resultMap.containsKey("msg")) {
                errMsg = errMsg + "请求OMS中响应信息不正确,";
                continue;
            }
            if (resultMap.get("success").toString().equals("n")) {
                if (resultMap.get("msg").toString().equals("ITEM_NOT_FOUND_MESSAGE")) {
                    errItemNotFound = errItemNotFound + httpItemVo.getEcItemCode() + ",\\n";
                } else if (resultMap.get("msg").toString().equals("该商品已被删除")) {
                    errDeleted = errDeleted + httpItemVo.getEcItemCode() + ",\\n";
                } else if (resultMap.get("msg").toString().equals("店铺不存在")) {
                    errShopNonentity = errShopNonentity + httpItemVo.getEcItemCode() + ",\\n";
                } else if (resultMap.get("msg").toString().equals("上架的数量必须大于0")) {
                    errQty = errQty + httpItemVo.getEcItemCode() + ",\\n";
                } else {
                	errSystem = "系统发生错误，请联系开发人员。";
                }
                
                continue;
            }
            // 平台商品库存为0 上下架失败
            // if (listingFlg) {
            // SkuVO param = new SkuVO();
            // param.setEcItemId(ecitemid[i]);
            // List<SkuVO> skuVOList = findByWhere(param);
            // Integer qtyCount = 0;
            // for (SkuVO skuVO : skuVOList) {
            // if (skuVO.getQty() == 0) {
            // qtyCount++;
            // } else {
            // continue;
            // }
            // }
            // if (qtyCount == skuVOList.size()) {
            // errStock = errStock + httpItemVo.getEcItemCode() + ",";
            // continue;
            // }
            // }
            ItemVO itemVo = new ItemVO();
            itemVo.setEcItemId(ecitemid[i]);
            if (listingFlg) {
                itemVo.setApproveStatus("上架");
            } else {
                itemVo.setApproveStatus("下架");
            }
            itemDAO.updateItem(itemVo);
        }

        if (!"商品未找到,平台商品编码为：\\n".equals(errItemNotFound) || !"商品已删除,平台商品编码为：\\n".equals(errDeleted)
                || !"店铺不存在,平台商品编码为：\\n".equals(errShopNonentity) || !"上架数为0,平台商品编码为：\\n".equals(errQty)
                || !"".equals(errSystem)) {
            if (!"商品未找到,平台商品编码为：\\n".equals(errItemNotFound)) {
                errItemNotFound = errItemNotFound.substring(0, errItemNotFound.lastIndexOf(','));
                errMsg = errMsg + errItemNotFound + "\\n";
            }
            if (!"商品已删除,平台商品编码为：\\n".equals(errDeleted)) {
                errDeleted = errDeleted.substring(0, errDeleted.lastIndexOf(','));
                errMsg = errMsg + errDeleted + "\\n";
            }
            if (!"店铺不存在,平台商品编码为：\\n".equals(errShopNonentity)) {
                errShopNonentity = errShopNonentity.substring(0, errShopNonentity.lastIndexOf(','));
                errMsg = errMsg + errShopNonentity + "\\n";
            }
            if (!"上架数为0,平台商品编码为：\\n".equals(errQty)) {
                errQty = errQty.substring(0, errQty.lastIndexOf(','));
                errMsg = errMsg + errQty + "\\n";
            }
            if (!"".equals(errSystem)) {
                errMsg = errSystem + "\\n";
            }
            // if (!"商品库存为0,商品编码为:(".equals(errStock)) {
            // errStock = errStock.substring(0, errStock.lastIndexOf(','));
            // errMsg = errMsg + errStock + ")\\n";
            // }
        } else {
            errMsg = "";
        }

        return errMsg;
    }

    /**
     * 项目是否设置公式
     *
     * @return
     * @throws Exception
     */
    private boolean isSetFormula() throws Exception {
        CurrentUser currentUser = WebContextFactory.getWebContext().getCurrentUser();
        String prjId = currentUser.getCurrentProject().getPrjId();
        StockFmla fmla = stockPushService.getStockFmlaByProjectId(prjId);
        if (fmla == null || "".equals(fmla.getFormula())) {
            return false;
        } else {
            return true;
        }
    }

    /**
     * 同步店铺库存
     *
     * @param shopId 网店Id
     * @return 错误消息
     * @throws Exception 异常
     */
    @SuppressWarnings("unchecked")
    public String synchShopStock(String shopId) throws Exception {
        if (!isSetFormula()) {
            return "同步库存失败，该项目未设置库存公式";
        }

        // todo You like you to delete
        ShopVO shopVO = shopDAO.findById(shopId);
        ItemAdapter itemAdapter = ItemAdapterFactory.getAdapter(shopVO.getShopType());
        if (itemAdapter != null) {
            String msg = itemAdapter.synchShopStock(shopId);
            return "".equals(msg) ? "" : "以下平台商品库存同步失败\\n" + msg;
        } else {
            String requestStr = StringUtil.format("itemManager/autoSynchStock.action?shopId=%s", shopId);
            String requestUrl = jobAddress + requestStr;
            String resJson = HttpUtils.sendByGet(requestUrl, null);
            Map<String, Object> resultMap = JSON.parseObject(resJson, Map.class);
            String msg = resultMap.get("msg").toString();
            return "".equals(msg) ? "" : "以下平台商品库存同步失败\\n" + msg;
        }
    }

    /**
     * 同步商品库存
     *
     * @param ecItemId 平台商品Id列表
     * @return 错误消息
     * @throws Exception 异常
     */
    @SuppressWarnings("unchecked")
    public String synchItemStock(String[] ecItemId) throws Exception {
        if (!isSetFormula()) {
            return "同步库存失败，该项目未设置库存公式";
        }

        String errMsg = "";

        for (int i = 0; i < ecItemId.length; i++) {
            Map<String, Object> params = new HashMap<String, Object>();
            params.put("ecItemId", ecItemId[i]);
            ItemVO itemVO = itemDAO.selectItemForSynchStock(params);
            if (itemVO == null) {
                errMsg = errMsg + "平台规格Id:" + ecItemId[i] + "没有SKU数据\\n";
                continue;
            }
            String shopId = itemVO.getShopId();

            // todo You like you to delete
            ShopVO shopVO = shopDAO.findById(shopId);
            ItemAdapter itemAdapter = ItemAdapterFactory.getAdapter(shopVO.getShopType());
            if (itemAdapter != null) {
                String msg = itemAdapter.synchItemStock(shopId, ecItemId[i]);
                if ("该店铺未配置可推送仓库".equals(msg) || "该店铺未设置仓库推送比例".equals(msg)) {
                    errMsg = msg;
                    break;
                }
                errMsg = errMsg + msg;
            } else {
                String requestStr = StringUtil.format("itemManager/manualSynchStockByItem.action?shopId=%s&ecItemId=%s", shopId,
                        ecItemId[i]);
                String requestUrl = jobAddress + requestStr;
                String resJson = HttpUtils.sendByGet(requestUrl, null);
                Map<String, Object> resultMap = JSON.parseObject(resJson, Map.class);
                String msg = resultMap.get("msg").toString();
                if ("该店铺未配置可推送仓库".equals(msg) || "该店铺未设置仓库推送比例".equals(msg)) {
                    errMsg = msg;
                    break;
                }
                errMsg = errMsg + msg;
            }
        }
        return "".equals(errMsg) ? "" : "以下平台商品库存同步失败\\n" + errMsg;
    }

    /**
     * 同步SKU库存
     *
     * @param ecSkuId 平台规格Id
     * @return 错误消息
     * @throws Exception 异常
     */
    @SuppressWarnings("unchecked")
    public String synchSkuStock(String ecSkuId) throws Exception {
        if (!isSetFormula()) {
            return "同步库存失败，该项目未设置库存公式";
        }

        Map<String, Object> params = new HashMap<String, Object>();
        params.put("ecSkuId", ecSkuId);
        ItemVO itemVO = itemDAO.selectItemForSynchStock(params);
        String shopId = itemVO.getShopId();

        // todo You like you to delete
        ShopVO shopVO = shopDAO.findById(shopId);
        ItemAdapter itemAdapter = ItemAdapterFactory.getAdapter(shopVO.getShopType());
        if (itemAdapter != null) {
            return itemAdapter.synchSkuStock(shopId, ecSkuId);
        } else {
            String requestStr = StringUtil.format("itemManager/manualSynchStockBySku.action?shopId=%s&ecSkuId=%s", shopId, ecSkuId);
            String requestUrl = jobAddress + requestStr;
            String resJson = HttpUtils.sendByGet(requestUrl, null);
            Map<String, Object> resultMap = JSON.parseObject(resJson, Map.class);
            return resultMap.get("msg").toString();
        }
    }

    /**
     * 批量修改SKU库存同步标识
     *
     * @param ecItemId  平台商品Id列表
     * @param autoStock 同步库存
     * @throws Exception 异常
     */
    public void batchUpdateAutoStock(String[] ecItemId, String autoStock) throws Exception {
        if (ecItemId != null) {
            for (int i = 0; i < ecItemId.length; i++) {
                SkuVO skuVo = new SkuVO();
                skuVo.setEcItemId(ecItemId[i]);
                skuVo.setAutoStock(autoStock);
                itemDAO.batchUpdateAutoStock(skuVo);
            }
        }
    }

    /**
     * 更新同步库存标识
     *
     * @param ecSkuId   平台规格Id
     * @param autoStock (y:可以同步,n:不)
     * @throws Exception 异常
     */
    public void updateAutoStock(String ecSkuId, String autoStock) throws Exception {
        SkuVO skuVO = new SkuVO();
        skuVO.setEcSkuId(ecSkuId);
        skuVO.setAutoStock(autoStock);
        itemDAO.updateSkubyEcSkuId(skuVO);
    }

    /**
     * 复制平台商品与系统商品
     */
    @Override
    public Map<String, Object> copyPlatformItem2SystemItem(String[] ecItemIds, String entId, String entName) throws Exception {
        Map<String, Object> returnValue = new HashMap<String, Object>();
        Integer count = 0;
        String errMsg = "添加到系统商品出错！\\n";
        String errNoSku = "以下商品没有商家编码：\\n";
        String tmpResult = "";
        String ecSkuNoOuterCodeMsg = "";
        for (String ecItemId : ecItemIds) {
            // 取出平台商品
            ItemVO aItem = getEcItemById(ecItemId);
            // 取平台商品sku
            List<SkuVO> skuList = itemDAO.selectSkuByEcItemId(ecItemId);

            // 如果这个平台商品及其下的规格都已经添加到系统了就不要再复制了
            Integer checkNum = 0;
            GoodsVO checkGoods = new GoodsVO();
            CurrentUser currentUser = WebContextFactory.getWebContext().getCurrentUser();
            checkGoods.setPrjId(currentUser.getCurrentProject().getPrjId());
            checkGoods.setGoodsCode(aItem.getOuterCode());
            checkGoods.setDeleted(YesNoConst.NO);
            // 取得系统商品
            PageInfo<GoodsVO> goodsVOList = goodsService.findByWhere(0, Integer.MAX_VALUE, checkGoods);
            if (null != goodsVOList && null != goodsVOList.getList() && goodsVOList.getList().size() > 0) {
                // 取得系统商品规格
                List<GoodsSkuVO> list = goodsService.getGoodsSkuByGoodsId(goodsVOList.getList().get(0).getGoodsId());
                for (SkuVO skuVO : skuList) {
                    for (GoodsSkuVO goodsSkuVO : list) {
                        if (skuVO.getOuterCode().equals(goodsSkuVO.getSkuCode())) {
                            checkNum++;
                        }
                    }
                }
            }
            if (skuList.size() == checkNum && skuList.size() > 0) {
                count++;
                continue;
            }

            if (null != goodsVOList && null != goodsVOList.getList() && goodsVOList.getList().size() > 0) {
                // 修改系统商品
                GoodsInfoVO goodsInfo = new GoodsInfoVO();
                goodsInfo.setAction("update");
                Goods goods = new Goods();
                goods.setAction("update");
                goods.setCatgId(goodsVOList.getList().get(0).getCatgId());
                goods.setCatgName(goodsVOList.getList().get(0).getCatgName());
                goods.setGoodCode(goodsVOList.getList().get(0).getGoodsCode());
                goods.setGoodName(goodsVOList.getList().get(0).getGoodsName());
                goods.setId(goodsVOList.getList().get(0).getGoodsId());
                goods.setRemark(goodsVOList.getList().get(0).getRemark());
                goodsInfo.setGoods(goods);

                // sku
                List<GoodsSku> arrSku = new ArrayList<GoodsSku>();
                List<GoodsSkuVO> list = goodsService.getGoodsSkuByGoodsId(goodsVOList.getList().get(0).getGoodsId());
                // 平台sku如果没有outerCode的话，就不能自动添加系统商品，并且要记录下来
                for (SkuVO sku : skuList) {
                    String remark = "";
                    for (GoodsSkuVO goodsSkuVO : list) {
                        if (sku.getOuterCode().equals(goodsSkuVO.getSkuCode())) {
                            remark = "todo";
                            break;
                        }
                    }
                    if (StringUtils.isNotBlank(remark)) {
                        remark = "";
                        continue;
                    }
                    GoodsSku goodsSku = new GoodsSku();
                    goodsSku.setId(java.util.UUID.randomUUID().toString().replaceAll("-", ""));
                    goodsSku.setAction("insert");
                    goodsSku.setBar("");
                    goodsSku.setGift(YesNoConst.NO);
                    goodsSku.setPrice(sku.getSalePrice().toString());
                    if (StringUtils.isNotBlank(sku.getOuterCode())) {
                        goodsSku.setSkuCode(sku.getOuterCode());
                    } else {
                        ecSkuNoOuterCodeMsg = ecSkuNoOuterCodeMsg + "," + sku.getEcSkuCode();
                        continue;
                    }
                    goodsSku.setSkuMCode(CodeUtil.getCode());
                    goodsSku.setSkuName(sku.getEcSkuName());
                    goodsSku.setStanPurcPrice(sku.getSalePrice().toString());
                    goodsSku.setVirt(YesNoConst.NO);
                    arrSku.add(goodsSku);
                }
                if (arrSku.size() == 0) {
                    errNoSku = errNoSku + aItem.getEcItemCode() + ",\\n";
                    continue;
                }
                goodsInfo.setArrSku(arrSku);

                Map<String, String> mapParm = new HashMap<String, String>();
                mapParm.put("entId", entId);
                mapParm.put("entName", entName);
                mapParm.put("prjId", aItem.getPrjId());
                mapParm.put("prjName", aItem.getPrjName());
                Map<String, Object> temp = goodsService.modifyGoodsData(goodsInfo, mapParm);
                // 由于goodsService.modifyGoodsData没有按编码规范组织返回参数，所以这里处理一下
                if (temp.containsKey("errorMessage")) {
                    returnValue.put("msg", temp.get("errorMessage"));
                }
                if (temp.containsKey("isOk")) {
                    tmpResult = temp.get("isOk").toString().equalsIgnoreCase(YesNoConst.NO) ? "failed" : "success";
                }

            } else {
                // 新增系统商品(系统商品 + 系统商品sku)
                GoodsInfoVO goodsInfo = new GoodsInfoVO();
                goodsInfo.setAction("insert");
                Goods goods = new Goods();
                goods.setAction("insert");
                goods.setCatgId("");
                goods.setCatgName("");
                goods.setGoodCode(aItem.getOuterCode());
                goods.setGoodName(aItem.getEcItemName());
                goods.setId(java.util.UUID.randomUUID().toString().replaceAll("-", ""));
                goods.setRemark(aItem.getRemark());
                goodsInfo.setGoods(goods);

                // sku
                List<GoodsSku> arrSku = new ArrayList<GoodsSku>();
                // 平台sku如果没有outerCode的话，就不能自动添加系统商品，并且要记录下来
                for (SkuVO sku : skuList) {
                    GoodsSku goodsSku = new GoodsSku();
                    goodsSku.setId(java.util.UUID.randomUUID().toString().replaceAll("-", ""));
                    goodsSku.setAction("insert");
                    goodsSku.setBar("");
                    goodsSku.setGift(YesNoConst.NO);
                    goodsSku.setPrice(sku.getSalePrice().toString());
                    if (StringUtils.isNotBlank(sku.getOuterCode())) {
                        goodsSku.setSkuCode(sku.getOuterCode());
                    } else {
                        ecSkuNoOuterCodeMsg = ecSkuNoOuterCodeMsg + "," + sku.getEcSkuCode();
                        continue;
                    }
                    goodsSku.setSkuMCode(CodeUtil.getCode());
                    goodsSku.setSkuName(sku.getEcSkuName());
                    goodsSku.setStanPurcPrice(sku.getSalePrice().toString());
                    goodsSku.setVirt(YesNoConst.NO);
                    arrSku.add(goodsSku);
                }
                if (arrSku.size() == 0) {
                    errNoSku = errNoSku + aItem.getEcItemCode() + ",\\n";
                    continue;
                }
                goodsInfo.setArrSku(arrSku);

                Map<String, String> mapParm = new HashMap<String, String>();
                mapParm.put("entId", entId);
                mapParm.put("entName", entName);
                mapParm.put("prjId", aItem.getPrjId());
                mapParm.put("prjName", aItem.getPrjName());
                Map<String, Object> temp = goodsService.modifyGoodsData(goodsInfo, mapParm);
                // 由于goodsService.modifyGoodsData没有按编码规范组织返回参数，所以这里处理一下
                if (temp.containsKey("errorMessage")) {
                    returnValue.put("msg", temp.get("errorMessage"));
                }
                if (temp.containsKey("isOk")) {
                    tmpResult = temp.get("isOk").toString().equalsIgnoreCase(YesNoConst.NO) ? "failed" : "success";
                }
            }
        }

        if (ecItemIds.length == count) {
            returnValue.put("result", "error");
            returnValue.put("msg", "商品已添加到系统商品");
        } else if (!"以下商品没有商家编码：\\n".equals(errNoSku)) {
            errNoSku = errNoSku.substring(0, errNoSku.lastIndexOf(','));
            errMsg = errMsg + errNoSku + "\\n";
            returnValue.put("result", "error");
            returnValue.put("msg", errMsg);
        } else if (StringUtils.isNotBlank(tmpResult)) {
            if ("success".equals(tmpResult)) {
                if (StringUtils.isEmpty(ecSkuNoOuterCodeMsg)) {
                    returnValue.put("msg", "添加成功");
                } else {
                    returnValue.put("msg", "部分商品添加成功（失败SKU编码" + ecSkuNoOuterCodeMsg + "）");
                }
            }
            returnValue.put("result", tmpResult);
        } else {
            returnValue.put("msg", "添加成功");
            returnValue.put("result", "success");
        }
        return returnValue;
    }

    //**************************** jipengcheng add 20180426 start *******************************************
    /**
     * OMS调用地址
     */
    @Value("${oms.address}")
    private String omsUrl;

    /**
     * 获取平台商品库存数
     *
     * @return
     */
    public Map<String, Object> getPlatformStockCount(ItemVO itemSku) throws Exception {
        Map<String, Object> returnMap = new HashMap<String, Object>();
        long storage = 0; // 库存数

        // 获取平台商品库存数
        if ("n".equals(itemSku.getIsGroup())) { // 非组合商品
            // 计算库存数
            JSONObject jsonObject = caculateStock(itemSku);
            if ("success".equals(jsonObject.get("result"))) {
                storage = Integer.parseInt(jsonObject.get("storage").toString());
            } else {
                String msg = (String) jsonObject.get("msg");
                logUtil.info(new DBLog(itemSku.getEcSkuCode(), "", "getPlatformStockCount",
                        DateUtil.getCurrentDateStr() + " 平台规格编码为【" + itemSku.getEcSkuCode() + "】同步失败," + msg));
                if ("该店铺未配置可推送仓库".equals(msg) || "该店铺未设置仓库推送比例".equals(msg)) {
                    returnMap.put("msg", msg);
                    returnMap.put("storage", 0);
                    return returnMap;
                }
                //returnMsg = returnMsg + "平台规格编码:" + itemSku.getEcSkuCode() + msg + "\\n";
            }
        } else { // 组合商品
            ItemVO searchItemVO = new ItemVO();
            searchItemVO.setEcSkuId(itemSku.getEcSkuId());
            List<ItemVO> groupSkuList = itemDAO.selectSkuForGroup(searchItemVO);

            for (int i = 0; i < groupSkuList.size(); i++) {
                ItemVO groupSku = groupSkuList.get(i);
                groupSku.setPrjId(itemSku.getPrjId());
                groupSku.setShopId(itemSku.getShopId());
                JSONObject jsonObject = caculateStock(groupSku);
                if ("success".equals(jsonObject.get("result"))) {
                    long tempStorage = Integer.parseInt(jsonObject.get("storage").toString());
                    double upRate = Float.parseFloat(groupSku.getUpRate());
                    long num = Integer.parseInt(groupSku.getNum());
                    // 库存 = 库存数 * 推送系数 / 数量 向下取整
                    tempStorage = (long) Math.floor(tempStorage * upRate / num);

                    // 取最小值
                    if (i == 0) {
                        storage = tempStorage;
                    } else {
                        if (tempStorage < storage) {
                            storage = tempStorage;
                        }
                    }
                } else {
                    String msg = (String) jsonObject.get("msg");
                    logUtil.info(new DBLog(itemSku.getEcSkuCode(), "", "getPlatformStockCount",
                            DateUtil.getCurrentDateStr() + " 平台规格编码为【" + itemSku.getEcSkuCode() + "】同步失败," + msg));
                    if ("该店铺未配置可推送仓库".equals(msg) || "该店铺未设置仓库推送比例".equals(msg)) {
                        returnMap.put("msg", msg);
                        returnMap.put("storage", 0);
                        return returnMap;
                    }
                    break;
                }
            }
        }
        returnMap.put("storage", storage);
        returnMap.put("msg", "");
        return returnMap;
    }

    /**
     * 计算库存数
     *
     * @param itemVO 平台商品VO
     * @return 计算结果
     * @throws Exception 异常
     */
    private JSONObject caculateStock(ItemVO itemVO) throws Exception {
        String requestStr = StringUtil.format("stockPush/caculateStock.action?projectId=%s&shopIds=%s&skuIds=%s", itemVO.getPrjId(),
                itemVO.getShopId(), itemVO.getSkuId());
        String requestUrl = omsUrl + requestStr;
        String resJson = HttpUtils.sendByGet(requestUrl, null);

        logUtil.info(new DBLog(itemVO.getSkuCode(), "getPlatformStockCount", "caculateStock", requestStr + "," + resJson));

        JSONObject jsonObject = JSON.parseObject(resJson, JSONObject.class);
        return jsonObject;
    }

    //**************************** jipengcheng add 20180426 end *******************************************
}
